package com.wang.ymcc.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.wang.lwm.constents.RedisConstents;
import com.wang.ymcc.domain.Course;
import com.wang.ymcc.domain.CourseType;
import com.wang.ymcc.dto.CourseTypeCrumbsVo;
import com.wang.ymcc.mapper.CourseTypeMapper;
import com.wang.ymcc.service.ICourseTypeService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author whale
 * @since 2022-10-25
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    @Autowired
    private CourseTypeMapper courseTypeMapper;

    @Override
    public List<CourseTypeCrumbsVo> crumbs(Long id) {
        CourseType courseType = courseTypeMapper.selectById(id);
        String path = courseType.getPath();
        String[] split = path.split("\\.");
        System.out.println(split.length);
        List<CourseTypeCrumbsVo> list = new ArrayList<>();
        for (String s : split) {
            CourseTypeCrumbsVo courseTypeCrumbsVo = new CourseTypeCrumbsVo();
            Long cid = Long.parseLong(s);
            CourseType cType = courseTypeMapper.selectById(cid);
            List<CourseType> courseTypes = courseTypeMapper.selectByPid(cType.getPid());
            courseTypeCrumbsVo.setOwnerProductType(cType);
            courseTypeCrumbsVo.setOtherProductTypes(courseTypes);
            list.add(courseTypeCrumbsVo);
        }
        return list;
    }

    /*
        1.把课程分类的数据放到redis里面

        查询的时候
            1.优先找redis
            2.如果redis里面没有 找数据库
            3.从数据库查询出来以后 放到redis里面

     */
    @Override
    @Cacheable(cacheNames = RedisConstents.COURSE_TYPE_IN_REDIS,key = "'all'")
    public List<CourseType> treeData() {
       /* List<CourseType> courseTypes=null;
        //1.优先找redis
        Object o = redisTemplate.opsForValue().get(RedisConstents.COURSE_TYPE_IN_REDIS);
        if (o!=null){
            courseTypes = (List<CourseType>) o;
        }else {
            //2.如果redis里面没有 找数据库
            courseTypes = treeData2DB();//去数据库取数据
            //3.从数据库查询出来以后 放到redis里面
            redisTemplate.opsForValue().set(RedisConstents.COURSE_TYPE_IN_REDIS,courseTypes);
        }*/
        return  treeData2DB();
    }

    public List<CourseType> treeData2DB() {
        //1.查询出所有的数据
        List<CourseType> courseTypes = selectList(null);
        //2.把数据转换为Map<Long,CourseType>
        Map<Long, CourseType> map = courseTypes.stream().collect(Collectors.toMap(CourseType::getId, CourseType -> CourseType));
       /* Map<Long, CourseType> collect1 = courseTypes.stream().collect(Collectors.toMap(CourseType::getId
           , new Function<CourseType, CourseType>() {
               @Override
               public CourseType apply(CourseType courseType) {
                   return courseType;
               }
           }
        );*/
        //3.准备一个集合，装第一层CourseType
        List<CourseType> firstCourseType = new ArrayList<>();
        courseTypes.forEach(courseType -> {
            if (courseType.getPid()==null||courseType.getPid()==0){
                //就是顶层的分类
                firstCourseType.add(courseType);
            }else {
                //4.不是顶层分类，根据pid找到父级，把自己添加到父级的children里面
                CourseType parent = map.get(courseType.getPid());
                if(parent!=null)parent.getChildren().add(courseType);
            }
        });
        return firstCourseType;
    }


    @Override
    @CacheEvict(cacheNames = RedisConstents.COURSE_TYPE_IN_REDIS,key = "'all'")
    public boolean insert(CourseType entity) {


        return super.insert(entity);//添加成功以后再删除
       /* if (b){
            redisTemplate.delete(RedisConstents.COURSE_TYPE_IN_REDIS);
        }
        return b;
        */

    }

    @Override
    @CacheEvict(cacheNames = RedisConstents.COURSE_TYPE_IN_REDIS,key = "'all'")
    public boolean deleteById(Serializable id) {
        return super.deleteById(id);
        /*if (b){
            redisTemplate.delete(RedisConstents.COURSE_TYPE_IN_REDIS);
        }
        return b;

         */
    }

    @Override
    @CacheEvict(cacheNames = RedisConstents.COURSE_TYPE_IN_REDIS,key = "'all'")
    public boolean updateById(CourseType entity) {
        return super.updateById(entity);
        /*
        if (b){
            redisTemplate.delete(RedisConstents.COURSE_TYPE_IN_REDIS);
        }
        return b;

         */
    }
}
